package package_traitement;


/**
 * matrice de cooccurrence d'une image
 * @author Alexandre Masson
 *
 */
public class MatriceCooccurrence {
	private int [][] parent;
	private int width_parent;
	private int height_parent;
	private int direction;
	private int pas;
	private int taille;
	int [][] coeff;
	//int compteur = 0;

	/**
	 * Constructeur
	 * 
	 * @param i 
	 * 			- image sur laquelle on va faire la matrice de cooccurence
	 * @param dir 
	 * 			- direction entre 0 et 7 : 0 etant le haut
	 * @param p 
	 * 			- pas de la matrice 
	 */
	public MatriceCooccurrence(int [][] i,int w, int h, int dir, int p, int t ){
		parent = i; 
		width_parent = w;
		height_parent = h;
		direction = (int)(((dir % 360)*Math.PI )/ 180);
		pas = p;
		//compteur = 0 ;
		taille = t;
		coeff = new int [taille][taille];
		int dx = (int)Math.ceil((Math.cos(direction)*(double)pas));
		int dy = (int)Math.ceil((Math.sin(direction)*(double)pas));
		gen(dx,dy);
	}

	/**
	 * Fonction qui retourne la coordonnee de debut du tableau
	 * 
	 * @param x
	 * 			- direction de dpart
	 * @return 
	 * 			- 0 si x est positif
	 * 			- -x sinon
	 */
	private int deb(int x){
		if(x < 0){
			return -x;
		}
		else return 0;
	}

	/**
	 * Fonction qui retourne la fin d'un tableau
	 * 
	 * @param x
	 * 			- direction utilisee
	 * @return
	 * 			- parent.Width() si x est negatif
	 * 			- parent.Width() - x si x est positif
	 * 
	 */
	private int finX(int x){
		if(x < 0){
			return width_parent;
		}
		else{
			return width_parent-pas;
		}
	}

	private int finY(int y){
		if(y < 0 ){
			return height_parent;
		}
		else{
			return height_parent-pas;
		}
	}



	/**
	 * Methode de generation de la matrice
	 */
	private void gen(int dx, int dy) {
		//System.out.println("x: "+dx+" y: "+dy);
		//on doit transformer toutes les images en images en niveau de gris
		int deby = deb(dy);
		int finy = finY(dy) ;
		int debx= deb(dx);
		int finx = finX(dx);
		for(int y = deby ; y< finy; y++ ){
			for(int x  = debx ; x< finx ; x++){
				int j = parent[x][y];
				int k = parent[x+dx][y+dy];
				coeff[j][k]++;
				//compteur++;
			}
		}
		//ensuite appliquer l'algo pour 
	}

	public int[][] getCoeff(){
		return coeff;
	}

	public int get(int x,int y){
		return coeff[x][y];
	}


	// GETTERS
	public void setDirection(int direction) {
		this.direction = direction;
	}
	public int getDirection() {
		return direction;
	}
	public void setPas(int pas) {
		this.pas = pas;
	}
	public int getPas() {
		return pas;
	}
	
	/**
	 * Fonction pour parser la matrice en String, utile pour les sauvegarde dans un fichier
	 */
	public String toString(){
		StringBuffer sbuf = new StringBuffer();
		for(int i = 0; i< taille ; i++){
			for(int j=0 ; j < taille ; j++){
				
				sbuf.append(coeff[j][i]);
				sbuf.append(" ");
			}
			//sbuf.append('\n');
		}
		return sbuf.toString();

	}


}
